home *** CD-ROM | disk | FTP | other *** search
/ The X-Philes (2nd Revision) / The X-Philes Number 1 (1995).iso / xphiles / hp48_2 / disasm.tar / disasm / instr8.c < prev    next >
C/C++ Source or Header  |  1990-04-25  |  7KB  |  335 lines
  1. #include "dis48.h"
  2.  
  3. char    *InStr80[16] = {
  4.     "out.s\t\tc", "out.x\t\tc", "in.4\t\ta", "in.4\t\tc", "uncnfg",
  5.     "config", "move.a\t\tid, c", "shutdn", NULL, "add.a\t\tp+1, c", "reset",
  6.     "buscc", NULL, NULL, "sreq", NULL
  7. };
  8.  
  9. char    *InStr808[16] = {
  10.     "inton", NULL, NULL, "buscb", NULL, NULL, NULL, NULL, NULL, NULL,
  11.     NULL, NULL, "jump.a\t\t@a", "buscd", "jump.a\t\t@c", "intoff"
  12. };
  13.  
  14. char *
  15. #ifdef ANSI
  16. Instr80(char *mem, NAddr *addr, char *out)
  17. #else
  18. Instr80(mem, addr, out)
  19. char    *mem;
  20. NAddr    *addr;
  21. char    *out;
  22. #endif
  23. {
  24.     Nybble    n;
  25.     Nybble    fn;
  26.     char    *p;
  27.     char    c;
  28.     NAddr    pc;
  29.     int    disp;
  30.     
  31.     n = GetNybble(mem, (*addr)++);
  32.     if ((p = InStr80[n]) != NULL)
  33.         return(AppendStr(out, p));
  34.         
  35.     switch (n) {
  36.     case 8:
  37.         fn = GetNybble(mem, (*addr)++);
  38.         if ((p = InStr808[fn]) != NULL) {
  39.             if ((n == 0xc) || (n == 0xe))
  40.                 itype = ujump;
  41.                 
  42.             return(AppendStr(out, p));
  43.         }
  44.             
  45.         switch (fn) {
  46.         case 1:
  47.             n = GetNybble(mem, (*addr)++);
  48.             p = AppendStr(out, (n == 0) ? "rsi" : "???");
  49.             break;
  50.             
  51.         case 2:
  52.             p = AppendStr(out, "move.p");
  53.             n = GetNybble(mem, (*addr)++);
  54.             p = Append16(p, n);
  55.             APPEND_TAB(p);
  56.             if ((p - out) < 8)
  57.                 APPEND_TAB(p);
  58.                 
  59.             p = AppendImmNyb(p, mem, addr, n + 1);
  60.             p = AppendStr(p, ", a");
  61.             break;
  62.             
  63.         case 4:
  64.         case 5:
  65.         case 8:
  66.         case 9:
  67.             p = AppendStr(out, (fn & 1) ? "setb\t\t" : "clrb\t\t");
  68.             p = AppendImmNyb(p, mem, addr, 1);
  69.             p = AppendStr(p, (fn & 8) ? ", c" : ", a");
  70.             break;
  71.             
  72.         case 6:
  73.         case 7:
  74.         case 0xa:
  75.         case 0xb:
  76.             c = (fn < 0xa) ? 'a' : 'c';
  77.             pc = *addr + 1;
  78.             n = GetNybble(mem, (*addr)++);
  79.             disp = GetInt(mem, addr, 2);
  80.             p = AppendStr(out, (disp == 0) ? "ret" : "br");
  81.             p = AppendStr(p, (fn & 1) ? "bs\t\t" : "bc\t\t");
  82.             APPEND_IMMMARK(p);
  83.             APPEND_HEXMARK(p);
  84.             APPEND_CHAR(p, hex[n]);
  85.             APPEND_COMMA(p);
  86.             APPEND_CHAR(p, c);
  87.             if (disp != 0) {
  88.                 APPEND_COMMA(p);
  89.                 p = AppendRAddr(p, pc, disp, 2, 5);
  90.             } else
  91.                 target = NOADDR;
  92.             
  93.             itype = branch;
  94.             break;
  95.         }
  96.         
  97.         break;
  98.         
  99.     case 0xc:
  100.     case 0xf:
  101.         p = AppendStr(out, (n == 0xc) ? "move" : "swap");
  102.         p = AppendStr(p, ".1\t\tp, c, ");
  103.         p = AppendImmNyb(p, mem, addr, 1);
  104.         break;
  105.         
  106.     case 0xd:
  107.         p = AppendStr(out, "move.1\t\tc, ");
  108.         p = AppendImmNyb(p, mem, addr, 1);
  109.         p = AppendStr(p, ", p");
  110.         break;
  111.     }
  112.     
  113.     return(p);
  114. }
  115.  
  116. char    *InStr81b[8] = {
  117.     NULL, NULL, "jump.a\t\ta", "jump.a\t\tc", "move.a\t\tpc, a",
  118.     "move.a\t\tpc, c", "swap.a\t\ta, pc", "swap.a\t\tc, pc"
  119. };
  120.  
  121. char    OpChr81[4] = {'a', 'b', 'c', 'd'};
  122.  
  123. char *
  124. #ifdef ANSI
  125. Instr81(char *mem, NAddr *addr, char *out)
  126. #else
  127. Instr81(mem, addr, out)
  128. char    *mem;
  129. NAddr    *addr;
  130. char    *out;
  131. #endif
  132. {
  133.     Nybble    n;
  134.     Nybble    fn;
  135.     char    *p;
  136.     char    c;
  137.     
  138.     switch (n = GetNybble(mem, (*addr)++)) {
  139.     case 0: case 1: case 2: case 3:
  140.         p = AppendStr(out, "rln.w\t\t");
  141.         APPEND_CHAR(p, OpChr81[n & 3]);
  142.         break;
  143.         
  144.     case 4: case 5: case 6: case 7:
  145.         p = AppendStr(out, "rrn.w\t\t");
  146.         APPEND_CHAR(p, OpChr81[n & 3]);
  147.         break;
  148.         
  149.     case 8:
  150.         fn = GetNybble(mem, (*addr)++);
  151.         n = GetNybble(mem, (*addr)++);
  152.         p = AppendStr(out, (n < 8) ? "add" : "sub");
  153.         p = AppendField(p, fn);
  154.         if ((p - out) < 9)
  155.             APPEND_TAB(p);
  156.             
  157.         fn = GetNybble(mem, (*addr)++);
  158.         APPEND_IMMMARK(p);
  159.         p = Append16(p, fn);
  160.         APPEND_COMMA(p);
  161.         APPEND_CHAR(p, OpChr81[n & 3]);
  162.         break;
  163.         
  164.     case 9:
  165.         p = AppendStr(out, "srb");
  166.         p = AppendField(p, GetNybble(mem, (*addr)++));
  167.         if ((p - out) < 9)
  168.             APPEND_TAB(p);
  169.             
  170.         APPEND_CHAR(p, OpChr81[GetNybble(mem, (*addr)++) & 3]);
  171.         break;
  172.     
  173.     case 0xa:
  174.         fn = GetNybble(mem, (*addr)++);
  175.         n = GetNybble(mem, (*addr)++);
  176.         p = AppendStr(out, (n == 2) ? "swap" : "move");
  177.         p = AppendField(p, fn);
  178.         if ((p - out) < 9)
  179.             APPEND_TAB(p);
  180.             
  181.         fn = GetNybble(mem, (*addr)++);
  182.         c = (fn < 8) ? 'a' : 'c';
  183.         fn = (fn & 7) + '0';
  184.         if (n == 1) {
  185.             APPEND_CHAR(p, 'r');
  186.             APPEND_CHAR(p, fn);
  187.         } else
  188.             APPEND_CHAR(p, c);
  189.             
  190.         APPEND_COMMA(p);
  191.         if (n == 1)
  192.             APPEND_CHAR(p, c);
  193.         else {
  194.             APPEND_CHAR(p, 'r');
  195.             APPEND_CHAR(p, fn);
  196.         }
  197.         
  198.         break;
  199.         
  200.     case 0xb:
  201.         n = GetNybble(mem, (*addr)++);
  202.         p = AppendStr(out, ((n < 2) || (n > 7)) ? "???" : InStr81b[n]);
  203.         itype = ujump;
  204.         break;
  205.         
  206.     case 0xc: case 0xd: case 0xe: case 0xf:
  207.         p = AppendStr(out, "srb.w\t\t");
  208.         APPEND_CHAR(p, OpChr81[n & 3]);
  209.         break;    
  210.     }
  211.     
  212.     return(p);
  213. }
  214.  
  215. char *
  216. #ifdef ANSI
  217. Instr8(char *mem, NAddr *addr, char *out)
  218. #else
  219. Instr8(mem, addr, out)
  220. char    *mem;
  221. NAddr    *addr;
  222. char    *out;
  223. #endif
  224. {
  225.     Nybble    n;
  226.     Nybble    fn;
  227.     char    *p;
  228.     char    c;
  229.     int    disp, pc;
  230.  
  231.     switch (fn = GetNybble(mem, (*addr)++)) {
  232.     case 0:
  233.         p = Instr80(mem, addr, out);
  234.         break;
  235.         
  236.     case 1:
  237.         p = Instr81(mem, addr, out);
  238.         break;
  239.     
  240.     case 2:
  241.         p = AppendStr(out, "clrb\t\t");
  242.         p = AppendStBits(p, GetNybble(mem, (*addr)++));
  243.         break;
  244.         
  245.     case 3:
  246.         n = GetNybble(mem, (*addr)++);
  247.         pc = *addr;
  248.         disp = GetInt(mem, addr, 2);
  249.         p = AppendStr(out, (disp == 0) ? "retbc\t\t" : "brbc\t\t");
  250.         p = AppendStBits(p, n);
  251.         if (disp != 0) {
  252.             APPEND_COMMA(p);
  253.             p = AppendRAddr(p, pc, disp, 2, 3);
  254.         } else
  255.             target = NOADDR;
  256.         
  257.         itype = branch;
  258.         break;
  259.     
  260.     case 4:
  261.     case 5:
  262.         p = AppendStr(out, (fn == 4) ? "clrb\t\t" : "setb\t\t");
  263.         p = AppendImmNyb(p, mem, addr, 1);
  264.         p = AppendStr(p, ", st");
  265.         break;
  266.         
  267.     case 6:
  268.     case 7:
  269.         c = (fn == 6) ? 'c' : 's';
  270.         n = GetNybble(mem, (*addr)++);
  271.         pc = *addr;
  272.         disp = GetInt(mem, addr, 2);
  273.         p = AppendStr(out, (disp == 0) ? "retb" : "brb");
  274.         APPEND_CHAR(p, c);
  275.         APPEND_TAB(p);
  276.         APPEND_TAB(p);
  277.         APPEND_IMMMARK(p);
  278.         APPEND_HEXMARK(p);
  279.         APPEND_CHAR(p, hex[n]);
  280.         p = AppendStr(p, ", st");
  281.         if (disp != 0) {
  282.             APPEND_COMMA(p);
  283.             p = AppendRAddr(p, pc, disp, 2, 3);
  284.         } else
  285.             target = NOADDR;
  286.         
  287.         itype = branch;
  288.         break;
  289.     
  290.     case 8:
  291.     case 9:
  292.         n = GetNybble(mem, (*addr)++);
  293.         pc = *addr;
  294.         disp = GetInt(mem, addr, 2);
  295.         p = AppendStr(out, (disp == 0) ?  "ret" : "br");
  296.         p = AppendStr(p, (fn == 8) ? "ne" : "eq");
  297.         p = AppendStr(p, "\t\tp, ");
  298.         APPEND_IMMMARK(p);
  299.         APPEND_CHAR(p, hex[n]);
  300.         if (disp != 0) {
  301.             APPEND_COMMA(p);
  302.             p = AppendRAddr(p, pc, disp, 2, 3);
  303.         } else
  304.             target = NOADDR;
  305.         
  306.         itype = branch;
  307.         break;
  308.     
  309.     case 0xc:
  310.     case 0xe:
  311.         pc = *addr;
  312.         if (fn == 0xe)
  313.             pc += 4;
  314.             
  315.         disp = GetInt(mem, addr, 4);
  316.         p = AppendStr(out, (fn == 0xc) ? "jump" : "call");
  317.         p = AppendStr(p, ".4\t\t");
  318.         p = AppendRAddr(p, pc, disp, 4, (fn == 0xc) ? 2 : 6);
  319.         itype = (fn == 0xc) ? jump : call;
  320.         break;
  321.         
  322.     case 0xd:
  323.     case 0xf:
  324.         p = AppendStr(out, (fn == 0xd) ? "jump" : "call");
  325.         p = AppendStr(p, ".a\t\t");
  326.         pc = GetInt(mem, addr, 5);
  327.         p = AppendAddr(p, pc);
  328.         itype = (fn == 0xd) ? jump : call;
  329.         target = pc;
  330.         break;
  331.     }
  332.  
  333.     return(p);    
  334. }
  335.